#include "Catalogo.h"
#include "Casillero.h"

void Contenedor::setLetraAsignada(char c){
	this->letraAsignada=c;
}

char Contenedor::getLetraAsignada(){
	return this->letraAsignada;
}

void Contenedor::setPieza(Pieza* pieza){
	this->pieza=pieza;
}

Pieza* Contenedor::getPieza(){
	return this->pieza;
}

void Catalogo::inicializarColores(){
	AZUL.rojo=0;AZUL.verde=0;AZUL.azul=255;
	KHAKI.rojo=189;KHAKI.verde=183;KHAKI.azul=107;

	AMARILLO.rojo=255;AMARILLO.verde=215;AMARILLO.azul=0;
	CELESTE.rojo=0;CELESTE.verde=255;CELESTE.azul=255;

	GRIS.rojo=128;GRIS.verde=128;GRIS.azul=128;
	INDIGO.rojo=75;INDIGO.verde=0;INDIGO.azul=130;

	NARANJA.rojo=255;NARANJA.verde=69;NARANJA.azul=0;
	NEGRO.rojo=0;NEGRO.verde=0;NEGRO.azul=0;

	ROSA.rojo=255;ROSA.verde=20;ROSA.azul=147;
	ROJO.rojo=255;ROJO.verde=0;ROJO.azul=0;

	VERDE.rojo=0;VERDE.verde=255;VERDE.azul=0;
	VERDE_OSCURO.rojo=0;VERDE_OSCURO.verde=100;VERDE_OSCURO.azul=0;

}

Catalogo::Catalogo() {
	/*Coleccion de piezas que tienen instancias de las piezas validas, de aca se obtendran los atributos de cada pieza para crearla*/
	inicializarColores();
	crearPiezaA(AZUL);
	crearPiezaB(KHAKI);
	crearPiezaC(AMARILLO);
	crearPiezaD(CELESTE);
	crearPiezaE(GRIS);
	crearPiezaF(INDIGO);
	crearPiezaG(NARANJA);
	crearPiezaH(ROSA);
	crearPiezaI(ROJO);
	crearPiezaJ(VERDE);
	crearPiezaK(KHAKI);
}

Catalogo::~Catalogo() {
		list<Contenedor*>::iterator iteradorDeLista=coleccionPiezas.begin();
		Contenedor* copia;
		int posicion;
		int tamanioLista=coleccionPiezas.size();
		for (posicion=1; posicion<=tamanioLista; posicion++){
			copia=*iteradorDeLista;
			delete copia->getPieza(); //borra la pieza DENTRO del contenedor
			delete copia;
			iteradorDeLista++;
		}
}


Pieza* Catalogo::getPieza(char letra){

	list<Contenedor*>::iterator iteradorDeLista=coleccionPiezas.begin();
	Pieza* punteroAPiezaElegida=NULL;

		for(unsigned int elemento=1;(elemento<=coleccionPiezas.size())&&((*iteradorDeLista)->getLetraAsignada()!=letra);elemento++){
			iteradorDeLista++;
		}

		if((*iteradorDeLista)->getLetraAsignada()==letra){
			punteroAPiezaElegida=new Pieza(*(*iteradorDeLista)->getPieza());
		}

		return punteroAPiezaElegida;

}
void Catalogo::crearPiezaA(Color color){

		Casillero** forma_A;
		unsigned int filas=1;
		unsigned int columnas=1;


		forma_A=new Casillero*[columnas];			//crea una matriz de casilleros
		for(unsigned int i=0;i<columnas;i++){
			forma_A[i]= new Casillero[filas];
		}
		forma_A[0][0].llenarCasillero(color);		//le carga algunos lugares llenos

		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_A, columnas,filas);
		Contenedor* unContenedor = new Contenedor();
			unContenedor->setLetraAsignada('A');
			unContenedor->setPieza(pieza);
		/*los contenedores de pieza se van agregando al final de la lista*/
		this->coleccionPiezas.push_back(unContenedor);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_A[i];
		}
		delete[] forma_A;


}
void Catalogo::crearPiezaB(Color color){

	Casillero** forma_B;
		unsigned int filas=2;
		unsigned int columnas=2;

		forma_B=new Casillero*[columnas];			//crea una matriz de casilleros
		for(unsigned int i=0;i<columnas;i++){
			forma_B[i]= new Casillero[filas];
		}
		forma_B[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_B[0][1].llenarCasillero(color);
		forma_B[1][0].llenarCasillero(color);
		forma_B[1][1].llenarCasillero(color);

		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_B,columnas, filas);
		Contenedor* unContenedor = new Contenedor();
					unContenedor->setLetraAsignada('B');
					unContenedor->setPieza(pieza);
		this->coleccionPiezas.push_back(unContenedor);


		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_B[i];
		}
		delete[] forma_B;


}
void Catalogo::crearPiezaC(Color color){

	Casillero** forma_C;
		unsigned int filas=3;
		unsigned int columnas=3;

		forma_C=new Casillero*[columnas];			//crea una matriz de casilleros
		for(unsigned int i=0;i<columnas;i++){
			forma_C[i]= new Casillero[filas];
		}
		forma_C[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_C[1][0].llenarCasillero(color);
		forma_C[2][0].llenarCasillero(color);
		forma_C[1][1].llenarCasillero(color);
		forma_C[1][2].llenarCasillero(color);


		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_C, columnas,filas);
		Contenedor* unContenedor = new Contenedor();
					unContenedor->setLetraAsignada('C');
					unContenedor->setPieza(pieza);
		this->coleccionPiezas.push_back(unContenedor);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_C[i];
		}
		delete[] forma_C;

}
void Catalogo::crearPiezaD(Color color){

	Casillero** forma_D;
		unsigned int filas=3;
		unsigned int columnas=2;

		forma_D=new Casillero*[columnas];			//crea una matriz de casilleros
		for(unsigned int i=0;i<columnas;i++){
			forma_D[i]= new Casillero[filas];
		}
		forma_D[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_D[0][1].llenarCasillero(color);
		forma_D[0][2].llenarCasillero(color);
		forma_D[1][1].llenarCasillero(color);



		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_D, columnas,filas);
		Contenedor* unContenedor = new Contenedor();
					unContenedor->setLetraAsignada('D');
					unContenedor->setPieza(pieza);
		this->coleccionPiezas.push_back(unContenedor);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_D[i];
		}
		delete[] forma_D;

}
void Catalogo::crearPiezaE(Color color){

	Casillero** forma_E;
		unsigned int filas=4;
		unsigned int columnas=1;

		forma_E=new Casillero*[columnas];			//crea una matriz de casilleros
			for(unsigned int i=0;i<columnas;i++){
				forma_E[i]= new Casillero[filas];
		}
		forma_E[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_E[0][1].llenarCasillero(color);
		forma_E[0][2].llenarCasillero(color);
		forma_E[0][3].llenarCasillero(color);



		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_E, columnas,filas);
		Contenedor* unContenedor = new Contenedor();
					unContenedor->setLetraAsignada('E');
					unContenedor->setPieza(pieza);
		this->coleccionPiezas.push_back(unContenedor);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_E[i];
		}
		delete[] forma_E;

}
void Catalogo::crearPiezaF(Color color){

	Casillero** forma_F;
		unsigned int filas=3;
		unsigned int columnas=3;

		forma_F=new Casillero*[columnas];			//crea una matriz de casilleros
					for(unsigned int i=0;i<columnas;i++){
						forma_F[i]= new Casillero[filas];
				}
		forma_F[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_F[0][1].llenarCasillero(color);
		forma_F[0][2].llenarCasillero(color);

		forma_F[1][2].llenarCasillero(color);
		forma_F[2][2].llenarCasillero(color);




		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_F, columnas,filas);
		Contenedor* unContenedor = new Contenedor();
					unContenedor->setLetraAsignada('F');
					unContenedor->setPieza(pieza);
		this->coleccionPiezas.push_back(unContenedor);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_F[i];
		}
		delete[] forma_F;

}
void Catalogo::crearPiezaG(Color color){

	Casillero** forma_G;
		unsigned int filas=3;
		unsigned int columnas=3;

		forma_G=new Casillero*[columnas];			//crea una matriz de casilleros
							for(unsigned int i=0;i<columnas;i++){
								forma_G[i]= new Casillero[filas];
						}
		forma_G[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_G[0][1].llenarCasillero(color);
		forma_G[0][2].llenarCasillero(color);

		forma_G[1][1].llenarCasillero(color);
		forma_G[2][1].llenarCasillero(color);
		forma_G[2][2].llenarCasillero(color);



		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_G, columnas,filas);
		Contenedor* unContenedor = new Contenedor();
					unContenedor->setLetraAsignada('G');
					unContenedor->setPieza(pieza);
		this->coleccionPiezas.push_back(unContenedor);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_G[i];
		}
		delete[] forma_G;

}
void Catalogo::crearPiezaH(Color color){

	Casillero** forma_H;
		unsigned int filas=5;
		unsigned int columnas=3;

		forma_H=new Casillero*[columnas];			//crea una matriz de casilleros
									for(unsigned int i=0;i<columnas;i++){
										forma_H[i]= new Casillero[filas];
								}
		forma_H[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_H[2][0].llenarCasillero(color);
		forma_H[0][1].llenarCasillero(color);

		forma_H[1][1].llenarCasillero(color);
		forma_H[2][1].llenarCasillero(color);
		forma_H[1][2].llenarCasillero(color);
		forma_H[1][3].llenarCasillero(color);
		forma_H[1][4].llenarCasillero(color);



		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_H, columnas,filas);
		Contenedor* unContenedor = new Contenedor();
					unContenedor->setLetraAsignada('H');
					unContenedor->setPieza(pieza);
		this->coleccionPiezas.push_back(unContenedor);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_H[i];
		}
		delete[] forma_H;

}
void Catalogo::crearPiezaI(Color color){

	Casillero** forma_I;
		unsigned int filas=3;
		unsigned int columnas=3;

		forma_I=new Casillero*[columnas];			//crea una matriz de casilleros
			for(unsigned int i=0;i<columnas;i++){
				forma_I[i]= new Casillero[filas];
			}
		forma_I[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_I[0][1].llenarCasillero(color);
		forma_I[0][2].llenarCasillero(color);

		forma_I[1][0].llenarCasillero(color);
		forma_I[1][1].llenarCasillero(color);
		forma_I[1][2].llenarCasillero(color);

		forma_I[2][0].llenarCasillero(color);
		forma_I[2][1].llenarCasillero(color);
		forma_I[2][2].llenarCasillero(color);


		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_I, columnas,filas);
		Contenedor* unContenedor = new Contenedor();
					unContenedor->setLetraAsignada('I');
					unContenedor->setPieza(pieza);
		this->coleccionPiezas.push_back(unContenedor);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_I[i];
		}
		delete[] forma_I;

}
void Catalogo::crearPiezaJ(Color color){

	Casillero** forma_J;
		unsigned int filas=2;
		unsigned int columnas=1;

		forma_J=new Casillero*[columnas];			//crea una matriz de casilleros
			for(unsigned int i=0;i<columnas;i++){
				forma_J[i]= new Casillero[filas];
		}
		forma_J[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_J[0][1].llenarCasillero(color);

		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_J, columnas,filas);
		Contenedor* unContenedor = new Contenedor();
					unContenedor->setLetraAsignada('J');
					unContenedor->setPieza(pieza);
		this->coleccionPiezas.push_back(unContenedor);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_J[i];
		}
		delete[] forma_J;

}
void Catalogo::crearPiezaK(Color color){

	Casillero** forma_K;
		unsigned int filas=5;
		unsigned int columnas=3;

		forma_K=new Casillero*[columnas];			//crea una matriz de casilleros
					for(unsigned int i=0;i<columnas;i++){
						forma_K[i]= new Casillero[filas];
				}
		forma_K[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_K[1][0].llenarCasillero(color);
		forma_K[2][0].llenarCasillero(color);

		forma_K[0][1].llenarCasillero(color);		//le carga algunos lugares llenos

		forma_K[2][1].llenarCasillero(color);

		forma_K[0][2].llenarCasillero(color);		//le carga algunos lugares llenos


		forma_K[0][3].llenarCasillero(color);		//le carga algunos lugares llenos

		forma_K[2][3].llenarCasillero(color);

		forma_K[0][4].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_K[1][4].llenarCasillero(color);
		forma_K[2][4].llenarCasillero(color);

		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_K, columnas,filas);
		Contenedor* unContenedor = new Contenedor();
					unContenedor->setLetraAsignada('K');
					unContenedor->setPieza(pieza);
		this->coleccionPiezas.push_back(unContenedor);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_K[i];
		}
		delete[] forma_K;

}
